home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume11 / jove.pch / part04 < prev    next >
Encoding:
Internet Message Format  |  1987-09-15  |  33.6 KB

  1. Subject:  v11i048:  Jove upgrade kit, Part04/04
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rs@uunet.UU.NET
  5.  
  6. Submitted-by: Jonathan Payne  <jpayne@cs.rochester.edu>
  7. Posting-number: Volume 11, Issue 48
  8. Archive-name: jove.pch/Part04
  9.  
  10. #! /bin/sh
  11. # This is a shell archive.  Remove anything before this line, then unpack
  12. # it by saving it into a file and typing "sh file".  To overwrite existing
  13. # files, type "sh file -c".  You can also feed this as standard input via
  14. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  15. # will see the following message at the end:
  16. #        "End of archive 4 (of 4)."
  17. # Contents:  jove.pch.4
  18. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  19. if test -f 'jove.pch.4' -a "${1}" != "-c" ; then 
  20.   echo shar: Will not clobber existing file \"'jove.pch.4'\"
  21. else
  22. echo shar: Extracting \"'jove.pch.4'\" \(31574 characters\)
  23. sed "s/^X//" >'jove.pch.4' <<'END_OF_FILE'
  24. Xdiff -c ojove/rec.c jove/rec.c
  25. X*** ojove/rec.c    Thu Jul 16 09:15:04 1987
  26. X--- jove/rec.c    Mon Jul 13 09:46:08 1987
  27. X***************
  28. X*** 51,57 ****
  29. X      (void) unlink(recfname);
  30. X  }
  31. X  
  32. X! static
  33. X  putaddr(addr, p)
  34. X  disk_line    addr;
  35. X  register File    *p;
  36. X--- 51,57 ----
  37. X      (void) unlink(recfname);
  38. X  }
  39. X  
  40. X! private
  41. X  putaddr(addr, p)
  42. X  disk_line    addr;
  43. X  register File    *p;
  44. X***************
  45. X*** 63,69 ****
  46. X          putc(*cp++ & 0377, p);
  47. X  }
  48. X  
  49. X! static
  50. X  putn(cp, nbytes)
  51. X  register char    *cp;
  52. X  register int    nbytes;
  53. X--- 63,69 ----
  54. X          putc(*cp++ & 0377, p);
  55. X  }
  56. X  
  57. X! private
  58. X  putn(cp, nbytes)
  59. X  register char    *cp;
  60. X  register int    nbytes;
  61. X***************
  62. X*** 74,80 ****
  63. X  
  64. X  /* Write out the line pointers for buffer B. */
  65. X  
  66. X! static
  67. X  dmppntrs(b)
  68. X  register Buffer    *b;
  69. X  {
  70. X--- 74,80 ----
  71. X  
  72. X  /* Write out the line pointers for buffer B. */
  73. X  
  74. X! private
  75. X  dmppntrs(b)
  76. X  register Buffer    *b;
  77. X  {
  78. X***************
  79. X*** 86,106 ****
  80. X  
  81. X  /* dump the buffer info and then the actual line pointers. */
  82. X  
  83. X! static
  84. X! dmp_buf(b)
  85. X  register Buffer    *b;
  86. X  {
  87. X!     static struct rec_entry    record;
  88. X      register Line    *lp;
  89. X      register int    nlines = 0;
  90. X  
  91. X      for (lp = b->b_first; lp != 0; lp = lp->l_next, nlines++)
  92. X!         ;
  93. X      strcpy(record.r_fname, b->b_fname ? b->b_fname : NullStr);
  94. X      strcpy(record.r_bname, b->b_name);
  95. X      record.r_nlines = nlines;
  96. X      putn((char *) &record, sizeof record);
  97. X-     dmppntrs(b);
  98. X  }
  99. X  
  100. X  /* Goes through all the buffers and syncs them to the disk. */
  101. X--- 86,107 ----
  102. X  
  103. X  /* dump the buffer info and then the actual line pointers. */
  104. X  
  105. X! private
  106. X! dmp_buf_header(b)
  107. X  register Buffer    *b;
  108. X  {
  109. X!     struct rec_entry    record;
  110. X      register Line    *lp;
  111. X      register int    nlines = 0;
  112. X  
  113. X      for (lp = b->b_first; lp != 0; lp = lp->l_next, nlines++)
  114. X!         if (lp == b->b_dot)
  115. X!             record.r_dotline = nlines;
  116. X      strcpy(record.r_fname, b->b_fname ? b->b_fname : NullStr);
  117. X      strcpy(record.r_bname, b->b_name);
  118. X      record.r_nlines = nlines;
  119. X+     record.r_dotchar = b->b_char;
  120. X      putn((char *) &record, sizeof record);
  121. X  }
  122. X  
  123. X  /* Goes through all the buffers and syncs them to the disk. */
  124. X***************
  125. X*** 110,115 ****
  126. X--- 111,117 ----
  127. X  SyncRec()
  128. X  {
  129. X      register Buffer    *b;
  130. X+     extern disk_line    DFree;
  131. X  
  132. X      if (rec_fd == 0)
  133. X          recinit();    /* Init recover file. */
  134. X***************
  135. X*** 123,128 ****
  136. X--- 125,131 ----
  137. X              continue;
  138. X          else
  139. X              Header.Nbuffers++;
  140. X+     Header.FreePtr = DFree;
  141. X      putn((char *) &Header, sizeof Header);
  142. X      if (Header.Nbuffers != 0) {
  143. X          SyncTmp();
  144. X***************
  145. X*** 130,136 ****
  146. X              if (b->b_type == B_SCRATCH || !IsModified(b))
  147. X                  continue;
  148. X              else
  149. X!                 dmp_buf(b);
  150. X      }
  151. X      flush(rec_out);
  152. X  }
  153. X--- 133,148 ----
  154. X              if (b->b_type == B_SCRATCH || !IsModified(b))
  155. X                  continue;
  156. X              else
  157. X!                 dmp_buf_header(b);
  158. X!         for (b = world; b != 0; b = b->b_next)
  159. X!             if (b->b_type == B_SCRATCH || !IsModified(b))
  160. X!                 continue;
  161. X!             else
  162. X!                 dmppntrs(b);
  163. X      }
  164. X      flush(rec_out);
  165. X+ }
  166. X+ 
  167. X+ FullRecover()
  168. X+ {
  169. X  }
  170. Xdiff -c ojove/rec.h jove/rec.h
  171. X*** ojove/rec.h    Thu Jul 16 09:15:06 1987
  172. X--- jove/rec.h    Thu Mar 19 17:13:30 1987
  173. X***************
  174. X*** 6,20 ****
  175. X   ************************************************************************/
  176. X  
  177. X  struct rec_head {
  178. X!     int    Uid,        /* Uid of owner. */
  179. X!         Pid;        /* Pid of jove process. */
  180. X!     time_t    UpdTime;    /* Last time this was updated. */
  181. X!     int    Nbuffers;    /* Number of buffers. */
  182. X  };
  183. X  
  184. X  struct rec_entry {
  185. X      char    r_bname[128],
  186. X          r_fname[128];
  187. X!     int    r_nlines;
  188. X  };
  189. X- 
  190. X--- 6,22 ----
  191. X   ************************************************************************/
  192. X  
  193. X  struct rec_head {
  194. X!     int        Uid,        /* uid of owner */
  195. X!             Pid;        /* pid of jove process */
  196. X!     time_t        UpdTime;    /* last time this was updated */
  197. X!     int        Nbuffers;    /* number of buffers */
  198. X!     disk_line    FreePtr;    /* position of DFree */
  199. X  };
  200. X  
  201. X  struct rec_entry {
  202. X      char    r_bname[128],
  203. X          r_fname[128];
  204. X!     int    r_nlines,
  205. X!         r_dotline,    /* so we can really save the context */
  206. X!         r_dotchar;
  207. X  };
  208. Xdiff -c ojove/recover.c jove/recover.c
  209. X*** ojove/recover.c    Thu Jul 16 09:15:12 1987
  210. X--- jove/recover.c    Mon Jul 13 12:00:15 1987
  211. X***************
  212. X*** 405,414 ****
  213. X              printf("recover: cannot create %s.\n", dest);
  214. X              return;
  215. X          }
  216. X-         seekto(src - buflist);
  217. X          if (dest != tty)
  218. X              printf("\"%s\"", dest);
  219. X!         dump_file(outfile);
  220. X      } else
  221. X          printf("\nAborted!\n");
  222. X      fclose(outfile);
  223. X--- 405,413 ----
  224. X              printf("recover: cannot create %s.\n", dest);
  225. X              return;
  226. X          }
  227. X          if (dest != tty)
  228. X              printf("\"%s\"", dest);
  229. X!         dump_file(src - buflist, outfile);
  230. X      } else
  231. X          printf("\nAborted!\n");
  232. X      fclose(outfile);
  233. X***************
  234. X*** 440,454 ****
  235. X  seekto(which)
  236. X  {
  237. X      struct rec_entry    rec;
  238. X  
  239. X!     fseek(ptrs_fp, (long) (sizeof Header), L_SET);
  240. X!     
  241. X!     while (which-- > 1) {
  242. X!         read_rec(&rec);
  243. X!         if (fseek(ptrs_fp, (long) rec.r_nlines * sizeof (disk_line),
  244. X!             L_INCR) == -1)
  245. X!             printf("recover: improper fseek!\n");
  246. X!     }
  247. X  }
  248. X  
  249. X  makblist()
  250. X--- 439,451 ----
  251. X  seekto(which)
  252. X  {
  253. X      struct rec_entry    rec;
  254. X+     long    offset;
  255. X+     int    i;
  256. X  
  257. X!     offset = sizeof (Header) + (Header.Nbuffers * sizeof (rec));
  258. X!     for (i = 1; i < which; i++)
  259. X!         offset += buflist[i]->r_nlines * sizeof (disk_line);
  260. X!     fseek(ptrs_fp, offset, L_SET);
  261. X  }
  262. X  
  263. X  makblist()
  264. X***************
  265. X*** 455,469 ****
  266. X  {
  267. X      int    i;
  268. X  
  269. X      for (i = 1; i <= Header.Nbuffers; i++) {
  270. X-         seekto(i);
  271. X          if (buflist[i] == 0)
  272. X              buflist[i] = (struct rec_entry *) malloc (sizeof (struct rec_entry));
  273. X          read_rec(buflist[i]);
  274. X      }
  275. X!     if (buflist[i]) {
  276. X          free((char *) buflist[i]);
  277. X          buflist[i] = 0;
  278. X      }
  279. X  }
  280. X  
  281. X--- 452,467 ----
  282. X  {
  283. X      int    i;
  284. X  
  285. X+     fseek(ptrs_fp, (long) sizeof (Header), L_SET);
  286. X      for (i = 1; i <= Header.Nbuffers; i++) {
  287. X          if (buflist[i] == 0)
  288. X              buflist[i] = (struct rec_entry *) malloc (sizeof (struct rec_entry));
  289. X          read_rec(buflist[i]);
  290. X      }
  291. X!     while (buflist[i]) {
  292. X          free((char *) buflist[i]);
  293. X          buflist[i] = 0;
  294. X+         i++;
  295. X      }
  296. X  }
  297. X  
  298. X***************
  299. X*** 481,496 ****
  300. X      return addr;
  301. X  }
  302. X  
  303. X! dump_file(out)
  304. X  FILE    *out;
  305. X  {
  306. X-     struct rec_entry    record;
  307. X      register int    nlines;
  308. X      register disk_line    daddr;
  309. X      char    buf[BUFSIZ];
  310. X  
  311. X!     read_rec(&record);
  312. X!     nlines = record.r_nlines;
  313. X      Nchars = Nlines = 0L;
  314. X      while (--nlines >= 0) {
  315. X          daddr = getaddr(ptrs_fp);
  316. X--- 479,493 ----
  317. X      return addr;
  318. X  }
  319. X  
  320. X! dump_file(which, out)
  321. X  FILE    *out;
  322. X  {
  323. X      register int    nlines;
  324. X      register disk_line    daddr;
  325. X      char    buf[BUFSIZ];
  326. X  
  327. X!     seekto(which);
  328. X!     nlines = buflist[which]->r_nlines;
  329. X      Nchars = Nlines = 0L;
  330. X      while (--nlines >= 0) {
  331. X          daddr = getaddr(ptrs_fp);
  332. X***************
  333. X*** 539,549 ****
  334. X  #ifdef KILL0
  335. X      if (kill(Header.Pid, 0) == 0)
  336. X          return 0;
  337. X- #else
  338. X- #ifdef LSRHS
  339. X-     if (pexist(Header.Pid))
  340. X-         return 0;
  341. X- #endif LSRHS
  342. X  #endif KILL0
  343. X  
  344. X      if (Header.Nbuffers == 0) {
  345. X--- 536,541 ----
  346. X***************
  347. X*** 568,573 ****
  348. X--- 560,566 ----
  349. X          return 1;
  350. X      }
  351. X      makblist();
  352. X+     list();
  353. X  
  354. X      for (;;) {
  355. X          tellme("(Type '?' for options): ", answer);
  356. X***************
  357. X*** 699,707 ****
  358. X          printf("recover: usage: recover [-d directory]\n");
  359. X          printf("Use \"recover\" after JOVE has died for some\n");
  360. X          printf("unknown reason.\n\n");
  361. X!         printf("Use \"recover -syscrash\" when the system is in the process\n");
  362. X          printf("of rebooting.  This is done automatically at reboot time\n");
  363. X          printf("and so most of you don't have to worry about that.\n\n");
  364. X          printf("Use \"recover -d directory\" when the tmp files are store\n");
  365. X          printf("in DIRECTORY instead of the default one (/tmp).\n");
  366. X          exit(0);
  367. X--- 692,701 ----
  368. X          printf("recover: usage: recover [-d directory]\n");
  369. X          printf("Use \"recover\" after JOVE has died for some\n");
  370. X          printf("unknown reason.\n\n");
  371. X! /*        printf("Use \"recover -syscrash\" when the system is in the process\n");
  372. X          printf("of rebooting.  This is done automatically at reboot time\n");
  373. X          printf("and so most of you don't have to worry about that.\n\n");
  374. X+  */
  375. X          printf("Use \"recover -d directory\" when the tmp files are store\n");
  376. X          printf("in DIRECTORY instead of the default one (/tmp).\n");
  377. X          exit(0);
  378. Xdiff -c ojove/screen.c jove/screen.c
  379. X*** ojove/screen.c    Thu Jul 16 09:15:18 1987
  380. X--- jove/screen.c    Mon Jul 13 08:34:13 1987
  381. X***************
  382. X*** 222,231 ****
  383. X  
  384. X  BufSwrite(linenum)
  385. X  {
  386. X-     char    *bp;
  387. X      register int    n = cursend - cursor,
  388. X              col = 0,
  389. X              c;
  390. X      int    StartCol = DesiredScreen[linenum].s_offset,
  391. X          visspace = DesiredScreen[linenum].s_window->w_flags & W_VISSPACE,
  392. X          aborted = 0;
  393. X--- 222,231 ----
  394. X  
  395. X  BufSwrite(linenum)
  396. X  {
  397. X      register int    n = cursend - cursor,
  398. X              col = 0,
  399. X              c;
  400. X+     register char    *bp;
  401. X      int    StartCol = DesiredScreen[linenum].s_offset,
  402. X          visspace = DesiredScreen[linenum].s_window->w_flags & W_VISSPACE,
  403. X          aborted = 0;
  404. X***************
  405. X*** 369,376 ****
  406. X     What ever turns you on ...   */
  407. X  
  408. X  private struct cursaddr {
  409. X!     int    c_numchars,
  410. X!         (*c_proc)();
  411. X  };
  412. X  
  413. X  private char    *Cmstr;
  414. X--- 369,376 ----
  415. X     What ever turns you on ...   */
  416. X  
  417. X  private struct cursaddr {
  418. X!     int    cm_numchars,
  419. X!         (*cm_proc)();
  420. X  };
  421. X  
  422. X  private char    *Cmstr;
  423. X***************
  424. X*** 532,538 ****
  425. X      register int    nlines = destline - CapLine;
  426. X  
  427. X      while (--nlines >= 0)
  428. X!         putchar('\n');
  429. X      CapLine = destline;
  430. X  }
  431. X  
  432. X--- 532,538 ----
  433. X      register int    nlines = destline - CapLine;
  434. X  
  435. X      while (--nlines >= 0)
  436. X!         putpad(NL, 1);
  437. X      CapLine = destline;
  438. X  }
  439. X  
  440. X***************
  441. X*** 574,580 ****
  442. X  
  443. X  #define CursMin(which,addrs,max) \
  444. X      for (best = 0, cp = &addrs[1], i = 1; i < max; i++, cp++) \
  445. X!         if (cp->c_numchars < addrs[best].c_numchars) \
  446. X              best = i; \
  447. X      which = &addrs[best];
  448. X  
  449. X--- 574,580 ----
  450. X  
  451. X  #define CursMin(which,addrs,max) \
  452. X      for (best = 0, cp = &addrs[1], i = 1; i < max; i++, cp++) \
  453. X!         if (cp->cm_numchars < addrs[best].cm_numchars) \
  454. X              best = i; \
  455. X      which = &addrs[best];
  456. X  
  457. X***************
  458. X*** 598,610 ****
  459. X  
  460. X      if (dcol == 1 || dcol == 0) {        /* Most common case. */
  461. X          HorMin = &WarpHor[FORWARD];
  462. X!         HorMin->c_numchars = dcol + xtracost;
  463. X      } else {
  464. X!         WarpHor[FORWARD].c_numchars = dcol >= 0 ? dcol + xtracost : 1000;
  465. X!         WarpHor[BACKWARD].c_numchars = dcol < 0 ? -(dcol + xtracost) : 1000;
  466. X!         WarpHor[FORTAB].c_numchars = dcol >= 0 && TABS ?
  467. X                  ForNum(CapCol, col) + xtracost : 1000;
  468. X!         WarpHor[RETFORWARD].c_numchars = (xtracost + 1 + (TABS ? ForNum(0, col) : col));
  469. X  
  470. X          /* Which is the shortest of the bunch */
  471. X  
  472. X--- 598,610 ----
  473. X  
  474. X      if (dcol == 1 || dcol == 0) {        /* Most common case. */
  475. X          HorMin = &WarpHor[FORWARD];
  476. X!         HorMin->cm_numchars = dcol + xtracost;
  477. X      } else {
  478. X!         WarpHor[FORWARD].cm_numchars = dcol >= 0 ? dcol + xtracost : 1000;
  479. X!         WarpHor[BACKWARD].cm_numchars = dcol < 0 ? -(dcol + xtracost) : 1000;
  480. X!         WarpHor[FORTAB].cm_numchars = dcol >= 0 && TABS ?
  481. X                  ForNum(CapCol, col) + xtracost : 1000;
  482. X!         WarpHor[RETFORWARD].cm_numchars = (xtracost + 1 + (TABS ? ForNum(0, col) : col));
  483. X  
  484. X          /* Which is the shortest of the bunch */
  485. X  
  486. X***************
  487. X*** 613,620 ****
  488. X  
  489. X      /* Moving vertically is more simple. */
  490. X  
  491. X!     WarpVert[DOWN].c_numchars = dline >= 0 ? dline : 1000;
  492. X!     WarpVert[UPMOVE].c_numchars = dline < 0 ? ((-dline) * UPlen) : 1000;
  493. X  
  494. X      /* Which of these is simpler */
  495. X      CursMin(VertMin, WarpVert, NUMVERT);
  496. X--- 613,620 ----
  497. X  
  498. X      /* Moving vertically is more simple. */
  499. X  
  500. X!     WarpVert[DOWN].cm_numchars = dline >= 0 ? dline : 1000;
  501. X!     WarpVert[UPMOVE].cm_numchars = dline < 0 ? ((-dline) * UPlen) : 1000;
  502. X  
  503. X      /* Which of these is simpler */
  504. X      CursMin(VertMin, WarpVert, NUMVERT);
  505. X***************
  506. X*** 624,651 ****
  507. X         Homing first's total is the sum of the cost of homing
  508. X         and the sum of tabbing (if possible) to the right. */
  509. X      
  510. X!     if (VertMin->c_numchars + HorMin->c_numchars <= 3) {
  511. X          DirectMin = &WarpDirect[DIRECT];    /* A dummy ... */
  512. X!         DirectMin->c_numchars = 100;
  513. X      } else {
  514. X!         WarpDirect[DIRECT].c_numchars = CM ?
  515. X                  strlen(Cmstr = tgoto(CM, col, line)) : 1000;
  516. X!         WarpDirect[HOME].c_numchars = HOlen + line +
  517. X!                 WarpHor[RETFORWARD].c_numchars;
  518. X!         WarpDirect[LOWER].c_numchars = LLlen + ((ILI - line) * UPlen) +
  519. X!                 WarpHor[RETFORWARD].c_numchars;
  520. X          CursMin(DirectMin, WarpDirect, NUMDIRECT);
  521. X      }
  522. X  
  523. X!     if (HorMin->c_numchars + VertMin->c_numchars < DirectMin->c_numchars) {
  524. X          if (line != CapLine)
  525. X!             (*VertMin->c_proc)(line);
  526. X          if (col != CapCol) {
  527. X  #ifdef ID_CHAR
  528. X              if (IN_INSmode)    /* We may use real characters ... */
  529. X                  INSmode(0);
  530. X  #endif
  531. X!             (*HorMin->c_proc)(col);
  532. X          }
  533. X      } else {
  534. X  #ifdef ID_CHAR
  535. X--- 624,651 ----
  536. X         Homing first's total is the sum of the cost of homing
  537. X         and the sum of tabbing (if possible) to the right. */
  538. X      
  539. X!     if (VertMin->cm_numchars + HorMin->cm_numchars <= 3) {
  540. X          DirectMin = &WarpDirect[DIRECT];    /* A dummy ... */
  541. X!         DirectMin->cm_numchars = 100;
  542. X      } else {
  543. X!         WarpDirect[DIRECT].cm_numchars = CM ?
  544. X                  strlen(Cmstr = tgoto(CM, col, line)) : 1000;
  545. X!         WarpDirect[HOME].cm_numchars = HOlen + line +
  546. X!                 WarpHor[RETFORWARD].cm_numchars;
  547. X!         WarpDirect[LOWER].cm_numchars = LLlen + ((ILI - line) * UPlen) +
  548. X!                 WarpHor[RETFORWARD].cm_numchars;
  549. X          CursMin(DirectMin, WarpDirect, NUMDIRECT);
  550. X      }
  551. X  
  552. X!     if (HorMin->cm_numchars + VertMin->cm_numchars < DirectMin->cm_numchars) {
  553. X          if (line != CapLine)
  554. X!             (*VertMin->cm_proc)(line);
  555. X          if (col != CapCol) {
  556. X  #ifdef ID_CHAR
  557. X              if (IN_INSmode)    /* We may use real characters ... */
  558. X                  INSmode(0);
  559. X  #endif
  560. X!             (*HorMin->cm_proc)(col);
  561. X          }
  562. X      } else {
  563. X  #ifdef ID_CHAR
  564. X***************
  565. X*** 652,658 ****
  566. X          if (IN_INSmode && !MI)
  567. X              INSmode(0);
  568. X  #endif
  569. X!         (*DirectMin->c_proc)(line, col);
  570. X      }
  571. X  }
  572. X  
  573. X--- 652,658 ----
  574. X          if (IN_INSmode && !MI)
  575. X              INSmode(0);
  576. X  #endif
  577. X!         (*DirectMin->cm_proc)(line, col);
  578. X      }
  579. X  }
  580. X  
  581. X***************
  582. X*** 716,727 ****
  583. X      register int    i;
  584. X  
  585. X      if (CS) {
  586. X!         putpad(tgoto(CS, bottom, top));
  587. X          CapCol = CapLine = 0;
  588. X          Placur(top, 0);
  589. X          for (i = 0; i < num; i++)
  590. X              putpad(SR, bottom - top);
  591. X!         putpad(tgoto(CS, ILI, 0));
  592. X          CapCol = CapLine = 0;
  593. X      } else {
  594. X          Placur(bottom - num + 1, 0);
  595. X--- 716,727 ----
  596. X      register int    i;
  597. X  
  598. X      if (CS) {
  599. X!         putpad(tgoto(CS, bottom, top), 1);
  600. X          CapCol = CapLine = 0;
  601. X          Placur(top, 0);
  602. X          for (i = 0; i < num; i++)
  603. X              putpad(SR, bottom - top);
  604. X!         putpad(tgoto(CS, ILI, 0), 1);
  605. X          CapCol = CapLine = 0;
  606. X      } else {
  607. X          Placur(bottom - num + 1, 0);
  608. X***************
  609. X*** 785,796 ****
  610. X      register int    i;
  611. X  
  612. X      if (CS) {
  613. X!         putpad(tgoto(CS, bottom, top));
  614. X          CapCol = CapLine = 0;
  615. X          Placur(bottom, 0);
  616. X          for (i = 0; i < num; i++)
  617. X              putpad(SF, bottom - top);
  618. X!         putpad(tgoto(CS, ILI, 0));
  619. X          CapCol = CapLine = 0;
  620. X      } else {
  621. X          Placur(top, 0);
  622. X--- 785,796 ----
  623. X      register int    i;
  624. X  
  625. X      if (CS) {
  626. X!         putpad(tgoto(CS, bottom, top), 1);
  627. X          CapCol = CapLine = 0;
  628. X          Placur(bottom, 0);
  629. X          for (i = 0; i < num; i++)
  630. X              putpad(SF, bottom - top);
  631. X!         putpad(tgoto(CS, ILI, 0), 1);
  632. X          CapCol = CapLine = 0;
  633. X      } else {
  634. X          Placur(top, 0);
  635. Xdiff -c ojove/term.c jove/term.c
  636. X*** ojove/term.c    Thu Jul 16 09:15:21 1987
  637. X--- jove/term.c    Wed Jun  3 16:31:57 1987
  638. X***************
  639. X*** 6,11 ****
  640. X--- 6,12 ----
  641. X   ************************************************************************/
  642. X  
  643. X  #include "jove.h"
  644. X+ #include <ctype.h>
  645. X  #include <errno.h>
  646. X  #ifdef SYSV
  647. X  #   include <termio.h>
  648. X***************
  649. X*** 48,60 ****
  650. X      *SF,    /* Scroll forward */
  651. X      *SR,
  652. X      *SP,    /* Send Cursor Position */
  653. X- #ifdef LSRHS
  654. X-     *RS,    /* Reverse video start */
  655. X-     *RE,    /* Reverse end */
  656. X- #endif
  657. X      *VB,
  658. X      *IP,    /* insert pad after character inserted */
  659. X!     *lPC;
  660. X  
  661. X  int    LI,
  662. X      ILI,    /* Internal lines, i.e., 23 of LI is 24. */
  663. X--- 49,59 ----
  664. X      *SF,    /* Scroll forward */
  665. X      *SR,
  666. X      *SP,    /* Send Cursor Position */
  667. X      *VB,
  668. X+     *BL,
  669. X      *IP,    /* insert pad after character inserted */
  670. X!     *lPC,
  671. X!     *NL;
  672. X  
  673. X  int    LI,
  674. X      ILI,    /* Internal lines, i.e., 23 of LI is 24. */
  675. X***************
  676. X*** 70,103 ****
  677. X      HOlen,
  678. X      LLlen;
  679. X  
  680. X! #ifdef SYSV /* release 2, at least */
  681. X! char PC ;
  682. X  #else
  683. X  extern char    PC;
  684. X! #endif SYSV
  685. X  
  686. X  static char    tspace[256];
  687. X  
  688. X  /* The ordering of ts and meas must agree !! */
  689. X! #ifdef LSRHS
  690. X! static char    *ts="vsvealdlspcssosecmclcehoupbcicimdceillsfsrvbksketiteALDLICDCrsrepcip";
  691. X  static char    **meas[] = {
  692. X      &VS, &VE, &AL, &DL, &SP, &CS, &SO, &SE,
  693. X      &CM, &CL, &CE, &HO, &UP, &BC, &IC, &IM,
  694. X      &DC, &EI, &LL, &SF, &SR, &VB, &KS, &KE,
  695. X      &TI, &TE, &M_AL, &M_DL, &M_IC, &M_DC,
  696. X!     &RS, &RE, &lPC, &IP, 0
  697. X  };
  698. X- #else
  699. X- static char    *ts="vsvealdlspcssosecmclcehoupbcicimdceillsfsrvbksketiteALDLICDCpcip";
  700. X- static char    **meas[] = {
  701. X-     &VS, &VE, &AL, &DL, &SP, &CS, &SO, &SE,
  702. X-     &CM, &CL, &CE, &HO, &UP, &BC, &IC, &IM,
  703. X-     &DC, &EI, &LL, &SF, &SR, &VB, &KS, &KE,
  704. X-     &TI, &TE, &M_AL, &M_DL, &M_IC, &M_DC,
  705. X-     &lPC, &IP, 0
  706. X- };
  707. X- #endif
  708. X  
  709. X  static
  710. X  gets(buf)
  711. X--- 69,91 ----
  712. X      HOlen,
  713. X      LLlen;
  714. X  
  715. X! #ifdef SYSVR2 /* release 2, at least */
  716. X! char    PC;
  717. X  #else
  718. X  extern char    PC;
  719. X! #endif SYSVR2
  720. X  
  721. X  static char    tspace[256];
  722. X  
  723. X  /* The ordering of ts and meas must agree !! */
  724. X! static char    *ts="vsvealdlspcssosecmclcehoupbcicimdceillsfsrvbksketiteALDLICDCpcipblnl";
  725. X  static char    **meas[] = {
  726. X      &VS, &VE, &AL, &DL, &SP, &CS, &SO, &SE,
  727. X      &CM, &CL, &CE, &HO, &UP, &BC, &IC, &IM,
  728. X      &DC, &EI, &LL, &SF, &SR, &VB, &KS, &KE,
  729. X      &TI, &TE, &M_AL, &M_DL, &M_IC, &M_DC,
  730. X!     &lPC, &IP, &BL, &NL, 0
  731. X  };
  732. X  
  733. X  static
  734. X  gets(buf)
  735. X***************
  736. X*** 172,189 ****
  737. X  
  738. X      UL = tgetflag("ul");
  739. X  
  740. X! #ifdef LSRHS        /* We, at the high school, are the only ones who
  741. X!                do SO right in termcap, but unfortunately the
  742. X!                right SO doesn't look as good with modelines. */
  743. X!     if (RS)
  744. X!         SO = RS;
  745. X!     if (RE)
  746. X!         SE = RE;
  747. X!             /* I only ever use SO for the modeline anyway. */
  748. X  
  749. X! /* SO is really BOLDFACE!  Why is LS always right and the rest of the
  750. X!    world wrong? */
  751. X! #endif
  752. X  #ifdef ID_CHAR
  753. X      disp_opt_init();
  754. X  #endif
  755. X--- 160,177 ----
  756. X  
  757. X      UL = tgetflag("ul");
  758. X  
  759. X!     if (NL == 0)
  760. X!         NL = "\n";
  761. X!     else {            /* strip stupid padding information */
  762. X!         while (isdigit(*NL))
  763. X!             NL++;
  764. X!         if (*NL == '*')
  765. X!             NL++;
  766. X!     }
  767. X  
  768. X!     if (BL == 0)
  769. X!         BL = "\007";
  770. X! 
  771. X  #ifdef ID_CHAR
  772. X      disp_opt_init();
  773. X  #endif
  774. Xdiff -c ojove/termcap.h jove/termcap.h
  775. X*** ojove/termcap.h    Thu Jul 16 09:15:22 1987
  776. X--- jove/termcap.h    Fri May 29 16:28:21 1987
  777. X***************
  778. X*** 36,48 ****
  779. X      *SF,    /* Scroll forward */
  780. X      *SR,    /* Scroll reverse */
  781. X      *SP,    /* Send cursor position */
  782. X- #ifdef LSRHS
  783. X-     *RS,    /* reverse video start */
  784. X-     *RE,    /* reverse video end */
  785. X- #endif
  786. X      *VB,    /* visible bell */
  787. X      *IP,    /* insert pad after character inserted */
  788. X!     *lPC;
  789. X  
  790. X  extern int
  791. X      LI,        /* number of lines */
  792. X--- 36,46 ----
  793. X      *SF,    /* Scroll forward */
  794. X      *SR,    /* Scroll reverse */
  795. X      *SP,    /* Send cursor position */
  796. X      *VB,    /* visible bell */
  797. X+     *BL,    /* audible bell */
  798. X      *IP,    /* insert pad after character inserted */
  799. X!     *lPC,
  800. X!     *NL;    /* newline character (usually \n) */
  801. X  
  802. X  extern int
  803. X      LI,        /* number of lines */
  804. Xdiff -c ojove/tune.h jove/tune.h
  805. X*** ojove/tune.h    Thu Jul 16 09:15:22 1987
  806. X--- jove/tune.h    Fri May 29 11:14:40 1987
  807. X***************
  808. X*** 7,17 ****
  809. X  
  810. X  #define TUNED        /* don't touch this */
  811. X  
  812. X- /*#define LSRHS        /* if this is Lincoln-Sudbury Regional High School */
  813. X  /*#define MSDOS        /* if this is MSDOS */
  814. X  #define BSD4_2        /* Berkeley 4.2 BSD */
  815. X  /*#define BSD4_3    /* Berkeley 4.3 BSD */
  816. X  /*#define SYSV        /* for (System III/System V) UNIX systems */
  817. X  #ifdef BSD4_3
  818. X  #   ifndef BSD4_2
  819. X  #    define BSD4_2    /* 4.3 is 4.2 only different. */
  820. X--- 7,23 ----
  821. X  
  822. X  #define TUNED        /* don't touch this */
  823. X  
  824. X  /*#define MSDOS        /* if this is MSDOS */
  825. X  #define BSD4_2        /* Berkeley 4.2 BSD */
  826. X  /*#define BSD4_3    /* Berkeley 4.3 BSD */
  827. X  /*#define SYSV        /* for (System III/System V) UNIX systems */
  828. X+ /*#define SYSVR2    /* system 5, rel. 2 */
  829. X+ #ifdef SYSVR2
  830. X+ #   ifndef SYSV
  831. X+ #    define SYSV    /* SYSV is a subset of SYSVR2 */
  832. X+ #   endif
  833. X+ #endif
  834. X+ 
  835. X  #ifdef BSD4_3
  836. X  #   ifndef BSD4_2
  837. X  #    define BSD4_2    /* 4.3 is 4.2 only different. */
  838. X***************
  839. X*** 36,42 ****
  840. X  #    define NBUF    3
  841. X  #   endif
  842. X  #
  843. X! /* #   define LOAD_AV    /* Use the load average for various commands.
  844. X  #               Do not define this if you lack a load average
  845. X  #               system call and kmem is read protected. */
  846. X  #
  847. X--- 42,48 ----
  848. X  #    define NBUF    3
  849. X  #   endif
  850. X  #
  851. X! #   define LOAD_AV    /* Use the load average for various commands.
  852. X  #               Do not define this if you lack a load average
  853. X  #               system call and kmem is read protected. */
  854. X  #
  855. X***************
  856. X*** 67,73 ****
  857. X  #       define BIFF        /* if you have biff (or the equivalent) */
  858. X  #       define F_COMPLETION    /* filename completion */
  859. X  #       define CHDIR        /* cd command and absolute pathnames */
  860. X! #       define    KILL0    /* kill(pid, 0) returns 0 if proc exists */
  861. X  #       define SPELL        /* spell words and buffer commands */
  862. X  #       define ID_CHAR        /* include code to IDchar */
  863. X  #       define WIRED_TERMS    /* include code for wired terminals */
  864. X--- 73,79 ----
  865. X  #       define BIFF        /* if you have biff (or the equivalent) */
  866. X  #       define F_COMPLETION    /* filename completion */
  867. X  #       define CHDIR        /* cd command and absolute pathnames */
  868. X! /*#       define    KILL0    /* kill(pid, 0) returns 0 if proc exists */
  869. X  #       define SPELL        /* spell words and buffer commands */
  870. X  #       define ID_CHAR        /* include code to IDchar */
  871. X  #       define WIRED_TERMS    /* include code for wired terminals */
  872. Xdiff -c ojove/util.c jove/util.c
  873. X*** ojove/util.c    Thu Jul 16 09:15:24 1987
  874. X--- jove/util.c    Fri Jun 19 16:01:01 1987
  875. X***************
  876. X*** 7,17 ****
  877. X  
  878. X  #include "jove.h"
  879. X  #include "ctype.h"
  880. X  #include <signal.h>
  881. X  #include <varargs.h>
  882. X  
  883. X! #ifdef SYSV /* release 2, at least */
  884. X! short ospeed ;
  885. X  #endif
  886. X  
  887. X  struct cmd *
  888. X--- 7,18 ----
  889. X  
  890. X  #include "jove.h"
  891. X  #include "ctype.h"
  892. X+ #include "termcap.h"
  893. X  #include <signal.h>
  894. X  #include <varargs.h>
  895. X  
  896. X! #ifdef SYSVR2 /* release 2, at least */
  897. X! short    ospeed;
  898. X  #endif
  899. X  
  900. X  struct cmd *
  901. X***************
  902. X*** 27,32 ****
  903. X--- 28,34 ----
  904. X  }
  905. X  
  906. X  int    Interactive;    /* True when we invoke with the command handler? */
  907. X+ data_obj    *LastCmd;
  908. X  char    *ProcFmt = ": %f ";
  909. X  
  910. X  ExecCmd(cp)
  911. X***************
  912. X*** 56,76 ****
  913. X  lastline(lp)
  914. X  register Line    *lp;
  915. X  {
  916. X!     while (lp->l_next)
  917. X!         lp = lp->l_next;
  918. X      return lp;
  919. X  }
  920. X  
  921. X! Upper(c)
  922. X! register int    c;
  923. X! {
  924. X!     return (islower(c) ? toupper(c) : c);
  925. X! }
  926. X  
  927. X- int    alarmed = 0;
  928. X- 
  929. X  char    key_strokes[100];
  930. X! static char    *key_p = key_strokes;
  931. X  
  932. X  init_strokes()
  933. X  {
  934. X--- 58,74 ----
  935. X  lastline(lp)
  936. X  register Line    *lp;
  937. X  {
  938. X!     register Line    *next;
  939. X! 
  940. X!     while (next = lp->l_next)
  941. X!         lp = next;
  942. X      return lp;
  943. X  }
  944. X  
  945. X! private int    *slowp = 0;
  946. X  
  947. X  char    key_strokes[100];
  948. X! private char    *key_p = key_strokes;
  949. X  
  950. X  init_strokes()
  951. X  {
  952. X***************
  953. X*** 88,94 ****
  954. X  
  955. X  slowpoke()
  956. X  {
  957. X!     alarmed++;
  958. X      f_mess(key_strokes);
  959. X  }
  960. X  
  961. X--- 86,93 ----
  962. X  
  963. X  slowpoke()
  964. X  {
  965. X!     if (slowp)
  966. X!         *slowp = YES;
  967. X      f_mess(key_strokes);
  968. X  }
  969. X  
  970. X***************
  971. X*** 95,104 ****
  972. X  #ifdef BSD4_2
  973. X  #    define N_SEC    1    /* will be precisely 1 second on 4.2 */
  974. X  #else
  975. X! #    define N_SEC    2    /* but from 0 to 2 seconds otherwise */
  976. X  #endif
  977. X  
  978. X! waitchar()
  979. X  {
  980. X  #ifdef EUNICE
  981. X      return getch();
  982. X--- 94,104 ----
  983. X  #ifdef BSD4_2
  984. X  #    define N_SEC    1    /* will be precisely 1 second on 4.2 */
  985. X  #else
  986. X! #    define N_SEC    2    /* but from 1 to 2 seconds otherwise */
  987. X  #endif
  988. X  
  989. X! waitchar(slow)
  990. X! int    *slow;
  991. X  {
  992. X  #ifdef EUNICE
  993. X      return getch();
  994. X***************
  995. X*** 107,113 ****
  996. X      int    c;
  997. X      int    (*oldproc)();
  998. X  
  999. X!     alarmed = 0;
  1000. X      oldproc = signal(SIGALRM, slowpoke);
  1001. X  
  1002. X      if ((old_time = alarm((unsigned) N_SEC)) == 0)
  1003. X--- 107,115 ----
  1004. X      int    c;
  1005. X      int    (*oldproc)();
  1006. X  
  1007. X!     slowp = slow;
  1008. X!     if (slow)
  1009. X!         *slow = NO;
  1010. X      oldproc = signal(SIGALRM, slowpoke);
  1011. X  
  1012. X      if ((old_time = alarm((unsigned) N_SEC)) == 0)
  1013. X***************
  1014. X*** 214,220 ****
  1015. X      Eol();
  1016. X  }
  1017. X  
  1018. X! int    MarkThresh = 22;    /* Average screen size ... */
  1019. X  static int    line_diff;
  1020. X  
  1021. X  LineDist(nextp, endp)
  1022. X--- 216,222 ----
  1023. X      Eol();
  1024. X  }
  1025. X  
  1026. X! int    MarkThresh = 22;    /* average screen size ... */
  1027. X  static int    line_diff;
  1028. X  
  1029. X  LineDist(nextp, endp)
  1030. X***************
  1031. X*** 255,263 ****
  1032. X  PushPntp(line)
  1033. X  register Line    *line;
  1034. X  {
  1035. X-     exp_p = NO;
  1036. X      if (LineDist(curline, line) >= MarkThresh)
  1037. X!         SetMark();
  1038. X  }
  1039. X  
  1040. X  ToFirst()
  1041. X--- 257,264 ----
  1042. X  PushPntp(line)
  1043. X  register Line    *line;
  1044. X  {
  1045. X      if (LineDist(curline, line) >= MarkThresh)
  1046. X!         set_mark();
  1047. X  }
  1048. X  
  1049. X  ToFirst()
  1050. X***************
  1051. X*** 276,282 ****
  1052. X  {
  1053. X      register char    c;
  1054. X  
  1055. X!     if (dir > 0) {
  1056. X          while ((c = linebuf[curchar]) != 0 && !isword(c))
  1057. X              curchar++;
  1058. X          if (eolp()) {
  1059. X--- 277,283 ----
  1060. X  {
  1061. X      register char    c;
  1062. X  
  1063. X!     if (dir == FORWARD) {
  1064. X          while ((c = linebuf[curchar]) != 0 && !isword(c))
  1065. X              curchar++;
  1066. X          if (eolp()) {
  1067. X***************
  1068. X*** 319,325 ****
  1069. X  filename(b)
  1070. X  register Buffer    *b;
  1071. X  {
  1072. X!     return b->b_fname ? pr_name(b->b_fname) : "[No file]";
  1073. X  }
  1074. X  
  1075. X  char *
  1076. X--- 320,326 ----
  1077. X  filename(b)
  1078. X  register Buffer    *b;
  1079. X  {
  1080. X!     return b->b_fname ? pr_name(b->b_fname, YES) : "[No file]";
  1081. X  }
  1082. X  
  1083. X  char *
  1084. X***************
  1085. X*** 430,436 ****
  1086. X      return 0;
  1087. X  }
  1088. X  
  1089. X! /* Make `buf' modified and tell the redisplay code to update the modeline
  1090. X     if it will need to be changed. */
  1091. X  
  1092. X  int    ModCount = 0;
  1093. X--- 431,437 ----
  1094. X      return 0;
  1095. X  }
  1096. X  
  1097. X! /* Make `buf' (un)modified and tell the redisplay code to update the modeline
  1098. X     if it will need to be changed. */
  1099. X  
  1100. X  int    ModCount = 0;
  1101. X***************
  1102. X*** 439,447 ****
  1103. X  {
  1104. X      extern int    DOLsave;
  1105. X  
  1106. X!     if (!curbuf->b_modified)
  1107. X          UpdModLine++;
  1108. X!     curbuf->b_modified++;
  1109. X      DOLsave++;
  1110. X      if (!Asking)
  1111. X          ModCount++;
  1112. X--- 440,449 ----
  1113. X  {
  1114. X      extern int    DOLsave;
  1115. X  
  1116. X!     if (!curbuf->b_modified) {
  1117. X          UpdModLine++;
  1118. X!         curbuf->b_modified = YES;
  1119. X!     }
  1120. X      DOLsave++;
  1121. X      if (!Asking)
  1122. X          ModCount++;
  1123. X***************
  1124. X*** 449,457 ****
  1125. X  
  1126. X  unmodify()
  1127. X  {
  1128. X!     if (curbuf->b_modified)
  1129. X          UpdModLine++;
  1130. X!     curbuf->b_modified = 0;
  1131. X  }
  1132. X  
  1133. X  numcomp(s1, s2)
  1134. X--- 451,460 ----
  1135. X  
  1136. X  unmodify()
  1137. X  {
  1138. X!     if (curbuf->b_modified) {
  1139. X          UpdModLine++;
  1140. X!         curbuf->b_modified = NO;
  1141. X!     }
  1142. X  }
  1143. X  
  1144. X  numcomp(s1, s2)
  1145. X***************
  1146. X*** 500,506 ****
  1147. X  {
  1148. X      register char    *pp, *pp1;
  1149. X      register int    len;
  1150. X!     int    numchars;    /* Number of characters to copy forward */
  1151. X  
  1152. X      if (num <= 0)
  1153. X          return;
  1154. X--- 503,509 ----
  1155. X  {
  1156. X      register char    *pp, *pp1;
  1157. X      register int    len;
  1158. X!     int    numchars;    /* number of characters to copy forward */
  1159. X  
  1160. X      if (num <= 0)
  1161. X          return;
  1162. X***************
  1163. X*** 566,572 ****
  1164. X  char *
  1165. X  emalloc(size)
  1166. X  {
  1167. X!     char    *ptr;
  1168. X  
  1169. X      if (ptr = malloc((unsigned) size))
  1170. X          return ptr;
  1171. X--- 569,575 ----
  1172. X  char *
  1173. X  emalloc(size)
  1174. X  {
  1175. X!     register char    *ptr;
  1176. X  
  1177. X      if (ptr = malloc((unsigned) size))
  1178. X          return ptr;
  1179. X***************
  1180. X*** 606,613 ****
  1181. X  }
  1182. X  
  1183. X  #ifdef LOAD_AV
  1184. X! #  ifdef BSD4_2
  1185. X! #    ifdef PURDUE_EE
  1186. X  
  1187. X  get_la(dp)
  1188. X  double *dp;
  1189. X--- 609,616 ----
  1190. X  }
  1191. X  
  1192. X  #ifdef LOAD_AV
  1193. X! # ifdef BSD4_2
  1194. X! #   ifdef PURDUE_EE && (vax || gould)
  1195. X  
  1196. X  get_la(dp)
  1197. X  double *dp;
  1198. X***************
  1199. X*** 615,622 ****
  1200. X      *dp = (double) loadav(0) / 100.0;
  1201. X  }
  1202. X  
  1203. X! #    else PURDUE_EE
  1204. X  
  1205. X  #include <nlist.h>
  1206. X  
  1207. X  static struct    nlist nl[] = {
  1208. X--- 618,628 ----
  1209. X      *dp = (double) loadav(0) / 100.0;
  1210. X  }
  1211. X  
  1212. X! #   else PURDUE_EE
  1213. X  
  1214. X+ #ifdef sun
  1215. X+ #   include <sys/param.h>
  1216. X+ #endif
  1217. X  #include <nlist.h>
  1218. X  
  1219. X  static struct    nlist nl[] = {
  1220. X***************
  1221. X*** 628,634 ****
  1222. X--- 634,644 ----
  1223. X  get_la(dp)
  1224. X  double    *dp;
  1225. X  {
  1226. X+ #ifdef sun
  1227. X+     long    avenrun[3];
  1228. X+ #else
  1229. X      double    avenrun[3];
  1230. X+ #endif
  1231. X      static int    kmem = 0;
  1232. X  
  1233. X      if (kmem == -1) {
  1234. X***************
  1235. X*** 644,650 ****
  1236. X--- 654,664 ----
  1237. X      }
  1238. X      lseek(kmem, (long) nl[X_AVENRUN].n_value, 0);
  1239. X      read(kmem, (char *) avenrun, sizeof(avenrun));
  1240. X+ #ifdef sun
  1241. X+     *dp = (double) avenrun[0] / FSCALE;
  1242. X+ #else
  1243. X      *dp = avenrun[0];
  1244. X+ #endif
  1245. X  }
  1246. X  
  1247. X  #    endif PURDUE_EE
  1248. X***************
  1249. X*** 693,703 ****
  1250. X  strlen(s)
  1251. X  register char    *s;
  1252. X  {
  1253. X!     register char    *base = s + 1;    /* Can you say kludge? */
  1254. X  
  1255. X      while (*s++)
  1256. X          ;
  1257. X!     return (s - base);
  1258. X  }
  1259. X  
  1260. X  char *
  1261. X--- 707,717 ----
  1262. X  strlen(s)
  1263. X  register char    *s;
  1264. X  {
  1265. X!     register char    *base = s;
  1266. X  
  1267. X      while (*s++)
  1268. X          ;
  1269. X!     return (s - base) - 1;
  1270. X  }
  1271. X  
  1272. X  char *
  1273. X***************
  1274. X*** 719,725 ****
  1275. X          *s2;
  1276. X  {
  1277. X      if (!s1 || !s2)
  1278. X!         return 1;    /* Which is not zero ... */
  1279. X      while (*s1 == *s2++)
  1280. X          if (*s1++ == '\0')
  1281. X              return 0;
  1282. X--- 733,739 ----
  1283. X          *s2;
  1284. X  {
  1285. X      if (!s1 || !s2)
  1286. X!         return 1;    /* which is not zero ... */
  1287. X      while (*s1 == *s2++)
  1288. X          if (*s1++ == '\0')
  1289. X              return 0;
  1290. X***************
  1291. X*** 731,738 ****
  1292. X          *s2;
  1293. X  {
  1294. X      if (!s1 || !s2)
  1295. X!         return 1;    /* Which is not zero ... */
  1296. X!     while (*s1 == *s2++ || Upper(*s1) == Upper(s2[-1]))
  1297. X          if (*s1++ == '\0')
  1298. X              return 0;
  1299. X      return (*s1 - *--s2);
  1300. X--- 745,752 ----
  1301. X          *s2;
  1302. X  {
  1303. X      if (!s1 || !s2)
  1304. X!         return 1;    /* which is not zero ... */
  1305. X!     while (CharUpcase(*s1) == CharUpcase(*s2++))
  1306. X          if (*s1++ == '\0')
  1307. X              return 0;
  1308. X      return (*s1 - *--s2);
  1309. X***************
  1310. X*** 744,751 ****
  1311. X  register int    n;
  1312. X  {
  1313. X      if (!s1 || !s2)
  1314. X!         return 1;    /* Which is not zero ... */
  1315. X!     while (--n >= 0  && (*s1 == *s2++ || Upper(*s1) == Upper(s2[-1])))
  1316. X          if (*s1++ == '\0')
  1317. X              return 0;
  1318. X      return ((n < 0) ? 0 : *s1 - *--s2);
  1319. X--- 758,765 ----
  1320. X  register int    n;
  1321. X  {
  1322. X      if (!s1 || !s2)
  1323. X!         return 1;    /* which is not zero ... */
  1324. X!     while (--n >= 0  && (CharUpcase(*s1) == CharUpcase(*s2++)))
  1325. X          if (*s1++ == '\0')
  1326. X              return 0;
  1327. X      return ((n < 0) ? 0 : *s1 - *--s2);
  1328. Xdiff -c ojove/vars.c jove/vars.c
  1329. X*** ojove/vars.c    Thu Jul 16 09:15:25 1987
  1330. X--- jove/vars.c    Thu May 28 12:48:29 1987
  1331. X***************
  1332. X*** 25,30 ****
  1333. X--- 25,31 ----
  1334. X      VARIABLE, "disable-biff", &BiffChk, V_BOOL,
  1335. X  #endif
  1336. X      VARIABLE, "error-window-size", &EWSize, V_BASE10,
  1337. X+     VARIABLE, "expand-environment-variables", &DoEVexpand, V_BOOL,
  1338. X      VARIABLE, "file-creation-mode", &CreatMode, V_BASE8,
  1339. X      VARIABLE, "files-should-end-with-newline", &EndWNewline, V_BOOL,
  1340. X      VARIABLE, "internal-tabstop", &tabstop, V_BASE10|V_CLRSCREEN,
  1341. Xdiff -c ojove/version.c jove/version.c
  1342. X*** ojove/version.c    Thu Jul 16 09:15:26 1987
  1343. X--- jove/version.c    Mon Jun 15 16:26:12 1987
  1344. X***************
  1345. X*** 5,8 ****
  1346. X   * included in all the files.                                           *
  1347. X   ************************************************************************/
  1348. X  
  1349. X! char    *version = "4.6.1.4";
  1350. X--- 5,8 ----
  1351. X   * included in all the files.                                           *
  1352. X   ************************************************************************/
  1353. X  
  1354. X! char    *version = "4.7";
  1355. Xdiff -c ojove/wind.c jove/wind.c
  1356. X*** ojove/wind.c    Thu Jul 16 09:15:28 1987
  1357. X--- jove/wind.c    Fri Jun 12 11:39:26 1987
  1358. X***************
  1359. X*** 219,225 ****
  1360. X  
  1361. X      DOTsave(&savedot);
  1362. X  
  1363. X!     switch (waitchar()) {
  1364. X      case 't':
  1365. X      case 'T':
  1366. X          ExecCmd((data_obj *) FindCmd(FindTag));
  1367. X--- 219,225 ----
  1368. X  
  1369. X      DOTsave(&savedot);
  1370. X  
  1371. X!     switch (waitchar((int *) 0)) {
  1372. X      case 't':
  1373. X      case 'T':
  1374. X          ExecCmd((data_obj *) FindCmd(FindTag));
  1375. X***************
  1376. X*** 354,365 ****
  1377. X  
  1378. X  GrowWindow()
  1379. X  {
  1380. X!     WindSize(curwind, abs(exp));
  1381. X  }
  1382. X  
  1383. X  ShrWindow()
  1384. X  {
  1385. X!     WindSize(curwind, -abs(exp));
  1386. X  }
  1387. X  
  1388. X  /* Change the size of the window by inc.  First arg is the window,
  1389. X--- 354,365 ----
  1390. X  
  1391. X  GrowWindow()
  1392. X  {
  1393. X!     WindSize(curwind, abs(arg_value()));
  1394. X  }
  1395. X  
  1396. X  ShrWindow()
  1397. X  {
  1398. X!     WindSize(curwind, -abs(arg_value()));
  1399. X  }
  1400. X  
  1401. X  /* Change the size of the window by inc.  First arg is the window,
  1402. X***************
  1403. X*** 434,438 ****
  1404. X  
  1405. X  SplitWind()
  1406. X  {
  1407. X!     SetWind(div_wind(curwind, exp_p ? (exp - 1) : 1));
  1408. X  }
  1409. X--- 434,460 ----
  1410. X  
  1411. X  SplitWind()
  1412. X  {
  1413. X!     SetWind(div_wind(curwind, is_an_arg() ? (arg_value() - 1) : 1));
  1414. X! }
  1415. X! 
  1416. X! /* Goto the window with the named buffer.  If no such window
  1417. X!    exists, pop one and attach the buffer to it. */
  1418. X! GotoWind()
  1419. X! {
  1420. X!     extern Buffer    *lastbuf;
  1421. X!     char    *bname;
  1422. X!     Window    *w;
  1423. X! 
  1424. X!     bname = ask_buf(lastbuf);
  1425. X!     w = curwind->w_next;
  1426. X!     do {
  1427. X!         if (w->w_bufp->b_name == bname) {
  1428. X!             SetABuf(curbuf);
  1429. X!             SetWind(w);
  1430. X!             return;
  1431. X!         }
  1432. X!         w = w->w_next;
  1433. X!     } while (w != curwind);
  1434. X!     SetABuf(curbuf);
  1435. X!     pop_wind(bname, NO, -1);
  1436. X  }
  1437. END_OF_FILE
  1438. if test 31574 -ne `wc -c <'jove.pch.4'`; then
  1439.     echo shar: \"'jove.pch.4'\" unpacked with wrong size!
  1440. fi
  1441. # end of 'jove.pch.4'
  1442. fi
  1443. echo shar: End of archive 4 \(of 4\).
  1444. cp /dev/null ark4isdone
  1445. MISSING=""
  1446. for I in 1 2 3 4 ; do
  1447.     if test ! -f ark${I}isdone ; then
  1448.     MISSING="${MISSING} ${I}"
  1449.     fi
  1450. done
  1451. if test "${MISSING}" = "" ; then
  1452.     echo You have unpacked all 4 archives.
  1453.     rm -f ark[1-9]isdone
  1454. else
  1455.     echo You still need to unpack the following archives:
  1456.     echo "        " ${MISSING}
  1457. fi
  1458. ##  End of shell archive.
  1459. exit 0
  1460.